
;;;======================================================
;;;   Asesor laboral
;;;
;;;     Pr�ctica del segundo cuatrimestre de IAIC.
;;;
;;;     Javier Pl� Herrero
;;;		Enrique L�pez Ma�as
;;;     
;;;======================================================


;;;======================================================
;;;  Nuestra pr�ctica utiliza un enfoque de coaching. La hemos
;;; orientado principalmente para asesorar a personas que 
;;; vayan a enfrentarse a una entrevista de trabajo c�mo
;;; hacerlo. 
;;;
;;;     Nuestras reglas comprenden tres fases: la primera, que
;;; la fase de recopilaci�n de conocimiento sobre la persona. 
;;; La segunda, que es la fase en la cual la persona va a atender
;;; o est� atendiendo la entrevista. La tercera, que es despu�s
;;; de haberla tomado
;;;
;;;     Se obtiene resultados sobre salarios a aceptar, 
;;; opciones sobre la idoneidad del trabajo, comportamiento ante
;;; una entrevista y tras ella. Todas las reglas vienen 
;;; documentadas, por lo que esperamos que os sean f�cil 
;;; entenderlas.
;;;		
;;;     
;;;======================================================


; *****
; RULES 
; *****

; RULE experiencia previa
; IF
;   Si est�s en la fase de selecci�n
; AND
;   Y no hay experiencia previa
; THEN
;   Considera hacer pr�cticas
;   Mejora tu formaci�n

(defrule experiencia-previa
   ( and
    ?phase <- (phase selection-phase)
   ?experience <- (experiencia noTieneExperiencia))
   =>
   (assert (consideraMejorarFormacionAcademica true))
   (assert (consideraUnasPracticas true))
	(printout t  "Considera mejorar tu formacion academica y unas practicas" )
)


; RULE aprender-ingles
; IF
;   Si no hablas ingles
; AND
;   Y no trabajas
; THEN
;   Considera estudiar ingles

(defrule aprender-ingles
   ( and
    ?job <- (empleo y)
   ?english <- (ingles n))
   =>
   (assert (consideraEstudiarIngles y))
	(printout t  "Considera estudiar Ingles" ))
    
    
; RULE viajar-al-extranjero
; IF
;   Debes estudiar ingl�s
; AND
;   No trabajas
; AND
;   Est�s disponible para viajes
; THEN
;   Vete al extranjero y aprende ingl�s

(defrule viajar-al-extranjero
   ( and
    ?job <- (empleo n)
   ?considerStudyingEnglish <- (consideraEstudiarIngles y)
   ?availabilityTravels <- (disponibilidadParaViajes y)
        )
   =>
   (assert (irAlExtranjero y))
	(printout t  "Una posibilidad es ir al extranjero" ))
    
    
; RULE erasmus
; IF
;   Si no has acabado la carrera
; AND
;   No trabajas
; AND
;   Deber�as ir al extranjero a aprender ingl�s
; THEN
;   Considera irte de Erasmus

(defrule erasmus
   ( and
    ?job <- (empleo n)
   	?goAbroad <- (irAlExtranjero y)
      ?degree <- (estudios acabados))
        
   =>
   (assert (erasmus y))
	(printout t  "Una buena opcion es irse de Erasmus" )))
    

; RULE salario-minimo-estudios-acabados
; IF
;   Si est�s en la fase de selecci�n
; AND
;   Ya has acabado la carrera
; THEN
;   Tu salario m�nimo deber�a ser 1000 �

(defrule salario-minimo-estudios-acabados
    (and
   ?phase <- (phase selection-phase)
   ?degree <- (estudios acabados))
   =>
   (assert (salario-minimo 1000))
	(printout t  "Salario de unos 1000" )))


; RULE salario-minimo-estudios-no-acabados
; IF
;   Est�s en la fase de selecci�n
; AND
;   No has acabado tu carrera
; THEN
;   Tu salario m�nimo deber�a ser de 400 �

(defrule minimum-wage-estudios-no-acabados
    (declare (salience 3))
   (and
    ?phase <- (phase selection-phase)
   ?degree <- (estudios no-acabados))
   =>
   (assert (salario-minimo 400))
	(printout t  "Salario de unos 400" )))

; RULE salario-minimo-ejecutivo
; IF
;   Si est�s en la fase de selecci�n
; AND
;   Si aspiras a una plaza de ejecutivo
; THEN
;   Tu salario m�nimo deber�a ser de 5000 �

(defrule salario-minimo-ejecutivo
    (declare (salience 3))
   (and
    ?phase <- (phase selection-phase)
   ?jobPosition <- (posicionDeseada ejecutivo))
   =>
   (assert (salario-minimo 5000))
	(printout t  "Salario de unos 5000" )))


; RULE salario-minimo-ingeniero
; IF
;   Si est�s en la fase de selecci�n
; AND
;   Si aspiras a una plaza de ejecutivo
; THEN
;   Tu salario m�nimo deber�a ser de 5 �

(defrule salario-minimo-ingeniero
    (declare (salience 3))
    ?jobPosition <- (posicionDeseada ingeniero)
   =>
   (assert (salario-minimo 5)))

; RULE salario-minimo-administrativo
; IF
;   Si est�s en la fase de selecci�n
; AND
;   Si aspiras a una plaza de administrativo
; THEN
;   Tu salario m�nimo deber�a ser de 400 �

(defrule salario-minimo-administrativo
    (declare (salience 3))
    ?jobPosition <- (posicionDeseada administrativo)
   =>
   (assert (salario-minimo 400))
	(printout t  "Un buen salario es de 400" )))

; RULE salario-minimo-trabajador
; IF
;   Si est�s en la fase de selecci�n
; AND
;   Est�s aspirando a una posici�n de trabajador
; THEN
;   Tu salario m�nimo deber�a ser de 800 �

(defrule salario-minimo-trabajador
    (declare (salience 3))
    (and
    ?phase <- (phase selection-phase)
    ?jobPosition <- (posicionDeseada trabajador))
   =>
   (assert (salario-minimo 800)))



; RULE tener-una-entrevista
; IF
;   Si te han llamado y has concretado una cita
; THEN
;   Vas a tener una entrevista

(defrule tener-una-entrevista
    (declare (salience 3))
   ?phase <- (teHanLlamado y)
   =>
   (assert (phase tener-entrevista)))


; RULE vestir-ejecutivo
; IF
;   Vas a tener una entrevista
; AND
;   Est�s aspirando a una posici�n ejecutiva
; THEN
;   Deber�as vestir bien y comprar un rolex

(defrule vestir-ejecutivo
    (declare (salience 3))
   (and
    ?phase <- (phase tener-entrevista)
   ?jobPosition <- (posicionDeseada ejecutivo))
   =>
   (assert (vestimenta buena))
      (assert (comprar rolex)))

; RULE relaciones-publicas
; IF
;   Si vas a tener una entrevista
; AND
;   Est�s aspirando a una posici�n de relaciones p�blicas
; THEN
;   Deber�as vestir bien

(defrule relaciones-publicas
    (declare (salience 3))
   (and
    ?phase <- (phase tener-entrevista)
   ?jobPosition <- (trabajoDeseado relacionesPublicas))
   =>
   (assert (vestimenta buena)))

; RULE recolectar-informacion
; IF
;   Si vas a tener una entrevista
; THEN
;   Deber�as recolectar informaci�n sobre el negocio

(defrule recolectar-informacion
    (declare (salience 3))
   ?phase <- (phase tener-entrevista)
     =>
   (assert (recolectar-informacion y)))

; RULE trabajo-deseado
; IF
;   Si quieres trabajar como Goku
; AND
;   Tienes experiencia en trabajos previos
; THEN
;   Deber�as pedir el trabajo en Namek

(defrule trabajo-deseado-goku
   ( and
    ?positionAimed <- (posicionDeseada super-goku)
    ?experience <- (experiencia tieneExperiencia))
   =>
   (assert (consideraEmpleoEnNamek)))


; RULE sobre-cualificacion
; IF
;   Si vas a tener una entrevista
; AND
;  Ya has finalizado tus estudios
; AND
; El trabajo es una pr�ctica
; THEN
;   Est�s sobre cualificado

(defrule sobre-cualificacion
    (declare (salience 3))
   (and
	?phase <- (phase tener-entrevista)
    ?degree <- (estudios acabados)
    ?jobPosition <- (trabajoDeseado practicas))
   
    =>
   (assert (cualificacion sobre)))

; RULE buena-cualificacion
; IF
;   Si vas a tener una entrevista
; AND
;  Ya has acabado tus estudios
; AND
; El trabajo es un trabajo para personas con estudiantes acabados
;OR
; AND
;  No has acabado tus estudios
; AND
; El trabajo son unas pr�cticas

; THEN
;   Tu calificaci�n es buena

(defrule buena-cualificacion
    (declare (salience 3))
   	(or
    (and
    ?phase <- (phase tener-entrevista)
    ?degree <- (estudios acabados)
    ?jobPosition <- (trabajoDeseado con-estudios-acabados))
        (or
    ?phase <- (phase tener-entrevista)        
    ?degree <- (estudios-acabados)
    ?jobPosition <- (trabajoDeseado practicas))
        )
   
    =>
   (assert (cualificacion buena)))



;; Mientras hacemos la entrevista...

; RULE saludar-con-la-mano
; IF
;   El entrevistador toma la iniciativa
; AND
;   Est�s tomando la entrevista
; THEN
;   Deber�as saludar fuerte con la mano

(defrule saluda-con-la-mano
    (declare (salience 3))
    (and
   (iniciativaEnLaEntrevista y)
   (phase en-la-entrevista))
   =>
   (assert (saluda-con-la-mano fuerte)))


; RULE saludos
; IF
;   El entrevistador no toma la iniciativa
; AND
;   Est�s tomando la entrevista
; THEN
;   Deber�as saludar suavemente con la mano

(defrule saludos
    (declare (salience 3))
    (and
   (phase en-la-entrevista)
   (iniciativaEnLaEntrevista n))
   =>
   (assert (saluda-con-la-mano suave)))


; RULE no-digas-mentiras
; IF
;   Saludas fuerte con la mano
; AND
;   Est�s tomando la entrevista
; THEN
;   No deber�as decir mentiras

(defrule no-digas-mentiras
    (declare (salience 3))
    (and
   (phase en-la-entrevista)
   (saluda-con-la-mano fuerte))
   =>
    (assert (puedes-mentir n)))


; RULE puedes-decir-mentiras
; IF
;   Saludas suavemente con la mano
; AND
;   Est�s tomando la entrevista
; THEN
;   Puedes decir algunas mentiras

(defrule puedes-decir-mentiras
    (declare (salience 3))
    (and
   (phase en-la-entrevista)
   (greet-with-hand soft))
   =>
   (assert (say-lies y)))



; RULE entrevistador-no-ofrece-asiento
; IF
;   El entrevistador no te ofrece un asiento
; THEN
;   El entrevistador es malo

(defrule entrevistador-no-ofrece-asiento
    (declare (salience 3))
   (entrevistadorOfreceAsiento n)
   =>
    (assert(entrevistador malo)))


; RULE entrevistador-ofrece-asiento
; IF
;   El entrevistador ofrece un asiento
; THEN
;   El entrevistador es bueno

(defrule entrevistador-ofrece-asiento
    (declare (salience 3))
   (entrevistadorOfreceAsiento y)
   =>
    (assert(entrevistador bueno)))


; RULE acabar-entrevista
; IF
;   La entrevista finaliza
; THEN
;   Mu�vete a la fase despues-de-entrevista

(defrule acabar-entrevista
    (declare (salience 3))
   (entrevistaAcabada y)
   =>
    (assert(phase despues-de-entrevista)))



; RULE actitud-impaciente
; IF
;   Si ya has tomado la entrevista
; THEN
;   No deber�as llamar

(defrule actitud-impaciente
    (declare (salience 3))
    (and
   (phase despues-de-entrevista)
   (entrevistaAcabada y))
   =>
    (assert(noLlames y)))
    
; RULE salario-mayor
; IF
;   Est�s despu�s de la entrevista
; AND
;   El entrevistador te ofrece un salario mayor que el tuyo
; THEN
;   Deber�as aceptar el trabajo

(defrule salario-mayor
    (declare (salience 3))
    (and
   (phase despues-de-entrevista)
   ?wage<-(salario-minimo)
   ?wage-offered<-(salario-ofrecido)
   (>?wage-offered ?wage)
   (entrevistaAcabada y))
   =>
    (assert(aceptarTrabajo y)))
    
 
 ; RULE salario-bajo
; IF
;   Est�s despu�s de la entrevista
; AND
;   El entrevistador te ofrece un salario menor que el tuyo
; AND
;	Est�s sobrecualificado
; THEN
;   No deber�as aceptar el trabajo

(defrule salario-bajo
    (declare (salience 3))
    (and
   (phase despues-de-entrevista)
   ?wage<-(salario-minimo)
   ?wage-offered<-(salario-ofrecido)
   (<?wage-offered ?wage)
   (cualificacion sobre)
   (entrevistaAcabada y))
   =>
    (assert(aceptarTrabajo n)))
    

; RULE consejo-de-trabajo1
; IF
;	Est�s despu�s de la entrevista
; AND
;	El entrevistador te ofrece un salario mayor que el tuyo
; AND
;	Est�s empleado
; OR
;   Est�s despu�s de la entrevista
; AND
;	Tienes una familia que sostener
; AND
;	Est�s desempleado
; THEN
;   Debes aceptar el trabajo

(defrule consejo-de-trabajo1
    (declare (salience 3))
    (or
    (and
   (phase despues-de-entrevista)
   (empleo y)
   ?wage<-(salario-actual)
   ?wage-offered<-(salario-ofrecido)
   (>?wage-offered ?wage))
   (and
   (phase despues-de-entrevista)
   (empleo n)
   (familia y)))
   =>
    (assert(aceptarTrabajo y)))


; RULE consejo-de-trabajo2
; IF
;   Est�s despu�s de la entrevista
; AND
;  Aspiras a un trabajo de Goku
; AND
;	Tienes sobre cualificaci�n
; THEN
;   Tienes que aceptar el trabajo

(defrule consejo-de-trabajo4
    (declare (salience 3))
    (and
   (phase despues-de-entrevista)
   (posicionDeseada super-goku)
   (cualificacion sobre)
   (entrevistaAcabada y))
   =>
    (assert(aceptarTrabajo n)))

(run)
